The present invention is generally directed to the handling of events in a data processing system. More particularly, the invention is directed to a system and method for event handling which employs a shared data structure which enables one thread to handle events originally presented to a different thread. Even more particularly the present invention enables one thread to pass event handling to another thread so that one thread does not have to wait for another thread to finish before the event is handled.
The present invention is employed in computer systems where multiple threads handle a number of events. However, at any given time only one thread is permitted to handle a given event. Thus, multiple threads are not allowed to work at the same time to handle the same event. An example of where such a requirement exists is when there is one thread associated with each adapter attached to a computer. (For purposes of best understanding the structure and operation of the present invention, an adapter is generally understood to mean a data communication device which permits the transmission of messages from one data processing node to another; in general, each data processing node includes its own random access memory and one or more data processing elements. The nodes transmit messages by means of individual adapter units through a switch which directs transmitted messages to receiving adapters in a multinodal data processing network).
If threads need to access a common data structure (as they do from time to time) only one thread is permitted to access this data structure at any given point in time. When the threads are doing work specific to their individual nodes, they can each work independently. However, when threads need to access a common resource through an adapter unit, such as a common data structure, only one thread is executed at a time.
The above situation is common in computer programs and there are various methods that may be employed to handle it. However, there are two additional requirements that complicate the present matter and make the current invention even more necessary. First, because of the time element involved in establishing, using and dismantling a system of locks and keys, it is not desirable to employ threads which use locking mechanisms as a solution to the data access problem herein since this use introduces appreciable amounts of undesirable wait times. Even though the use of locks is one of the ways to solve the problem of multiple threads seeking to access a common data structure, the desire to avoid the use of locks makes the solution to the present problem that much more difficult.
Another mechanism which is employable in solutions to the multiple thread access problem is through the creation of an entirely new and separate thread whose sole responsibility is managing access conflicts. However, the overhead associated with such a thread introduces another limitation in the path toward a solution of the multiple thread access problem. This second solution limitation also complicates the present matter since it is undesirable to create a thread that is used specifically and solely to access a shared resource, such as a shared data structure. This rules out the approach to the solution of this problem in which all access to the common resource is handled by a special thread that is dedicated only to that job. The overhead associated with establishing, managing, using and (eventually) closing such an additional thread is undesirably large.